{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "FLAGS = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-1f2e3e29ecda>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting Mnist_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting Mnist_data/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784) (55000, 10)\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = 'Mnist_data/'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)\n",
    "print(mnist.train.images.shape,mnist.train.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义各层神经元数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input_layer = 28 * 28  # 输入层\n",
    "n_output_layer = 10  # 输出层\n",
    "\n",
    "# 层数的选择：线性数据使用1层，非线性数据使用2层, 超级非线性使用3+层。层数、神经元过多会导致过拟合\n",
    "n_layer_1 = 1000  # hide layer\n",
    "n_layer_2 = 1300  # hide layer\n",
    "n_layer_3 = 800  # hide layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#获取一层神经网络的权重，并将权重的L2正则化损失加入到集合中\n",
    "def get_weight(shape,lamda):\n",
    "    #定义变量\n",
    "    var = tf.Variable(tf.random_normal(shape=shape),dtype=tf.float32)\n",
    "    #将变量的L2正则化损失添加到集合中\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(var))\n",
    "    return var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义3隐层神经网络\n",
    "def neural_network(x):\n",
    "    # 定义第一层\"神经元\"的权重和biases\n",
    "    layer_1_w_b = {'w_': tf.Variable(tf.random_normal([n_input_layer, n_layer_1])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_1]))}\n",
    "    # 定义第二层\"神经元\"的权重和biases\n",
    "    layer_2_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_1, n_layer_2])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_2]))}\n",
    "    # 定义第三层\"神经元\"的权重和biases\n",
    "    layer_3_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_2, n_layer_3])),\n",
    "                   'b_': tf.Variable(tf.random_normal([n_layer_3]))}\n",
    "    # 定义输出层\"神经元\"的权重和biases\n",
    "    layer_output_w_b = {'w_': tf.Variable(tf.random_normal([n_layer_3, n_output_layer])),\n",
    "                        'b_': tf.Variable(tf.random_normal([n_output_layer]))}\n",
    " \n",
    "    # w·x+b\n",
    "    layer_1 = tf.add(tf.matmul(x, layer_1_w_b['w_']), layer_1_w_b['b_'])\n",
    "    layer_1 = tf.nn.selu(layer_1)  # 激活函数 relu sigmoid  tanh elu  softplus\n",
    "    layer_2 = tf.add(tf.matmul(layer_1, layer_2_w_b['w_']), layer_2_w_b['b_'])\n",
    "    layer_2 = tf.nn.selu(layer_2)  # 激活函数\n",
    "    layer_3 = tf.add(tf.matmul(layer_2, layer_3_w_b['w_']), layer_3_w_b['b_'])\n",
    "    layer_3 = tf.nn.selu(layer_3)  # 激活函数\n",
    "    layer_output = tf.add(tf.matmul(layer_3, layer_output_w_b['w_']), layer_output_w_b['b_'])\n",
    " \n",
    "    return layer_output, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每次使用100条数据进行训练\n",
    "batch_size = 100\n",
    "\n",
    "x = tf.placeholder(dtype=tf.float32, shape=[None, n_input_layer])   # 输入数据占位符\n",
    "y = tf.placeholder(dtype=tf.float32, shape=[None, n_output_layer])   # 输出数据占位符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用数据训练神经网络\n",
    "def train_neural_network(X, Y, epochs=10):\n",
    "    #创建神经网络\n",
    "    y, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b = neural_network(X)\n",
    "    #代价函数\n",
    "    cost_func = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits= y, labels=Y))\n",
    "    #惩罚因子\n",
    "    lamda = 0.1\n",
    "    #将变量的L2正则化损失添加到集合中\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_1_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_2_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_3_w_b['w_']))\n",
    "    tf.add_to_collection(\"losses\",tf.contrib.layers.l2_regularizer(lamda)(layer_output_w_b['w_']))\n",
    "    #将代价函数与正则项合并\n",
    "    tf.add_to_collection(\"losses\",cost_func)\n",
    "    #获取整个模型的损失函数,tf.get_collection(\"losses\")返回集合中定义的损失\n",
    "    #将整个集合中的损失相加得到整个模型的损失函数\n",
    "    loss = tf.add_n(tf.get_collection(\"losses\"))\n",
    "\n",
    "    #学习速率，随迭代次数进行递减\n",
    "    global_step = tf.Variable(0, trainable=False)\n",
    "    starter_learning_rate = 0.0005\n",
    "    learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 5000, 0.96, staircase=True)\n",
    "    optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)  \n",
    "    # AdamOptimizer RMSPropOptimizer 表现最好\n",
    "    # AdamOptimizer GradientDescentOptimizer AdadeltaOptimizer FtrlOptimizer ProximalGradientDescentOptimizer \n",
    "    # ProximalAdagradOptimizer RMSPropOptimizer\n",
    " \n",
    "    with tf.Session() as session:\n",
    "        session.run(tf.initialize_all_variables())\n",
    "        \n",
    "        correct = tf.equal(tf.argmax(y, 1), tf.argmax(Y, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct, 'float'))\n",
    "        \n",
    "        epoch_loss = 0\n",
    "        epoch_loss_mat = []\n",
    "        epoch_accuracy_mat = []\n",
    "        epoch_accuracy_t_mat = []\n",
    "        for epoch in range(epochs):\n",
    "            for i in range(int(mnist.train.num_examples / batch_size)):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "                _, c = session.run([optimizer, loss], feed_dict={X: batch_xs, Y: batch_ys})\n",
    "                epoch_loss += c\n",
    "            epoch_accuracy = accuracy.eval({X: mnist.train.images, Y: mnist.train.labels})\n",
    "            epoch_accuracy_t = accuracy.eval({X: mnist.test.images, Y: mnist.test.labels})\n",
    "            print('epoch ', epoch, ' loss      : ', epoch_loss)\n",
    "            print('epoch ', epoch, ' accuracy  : ', epoch_accuracy)\n",
    "            print('epoch ', epoch, ' accuracy_t: ', epoch_accuracy_t)\n",
    "            epoch_loss_mat.append(epoch_loss)\n",
    "            epoch_accuracy_mat.append(epoch_accuracy)\n",
    "            epoch_accuracy_t_mat.append(epoch_accuracy_t)\n",
    "            epoch_loss = 0\n",
    " \n",
    "        \n",
    "        print('训练准确率: ', accuracy.eval({X: mnist.train.images, Y: mnist.train.labels}))\n",
    "        print('测试准确率: ', accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}))\n",
    "        \n",
    "        plt.plot(range(epochs), epoch_loss_mat) \n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('epoch_loss')\n",
    "        plt.show() \n",
    "        \n",
    "        plt.plot(range(epochs), epoch_accuracy_mat, label='Train Accuracy') \n",
    "        plt.plot(range(epochs), epoch_accuracy_t_mat, label='Test Accuracy')\n",
    "        plt.legend()\n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('accuracy')\n",
    "        plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-7-eaa991fc0a93>:6: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "tf.get_collection(\"losses\"):    [<tf.Tensor 'l2_regularizer:0' shape=() dtype=float32>, <tf.Tensor 'l2_regularizer_1:0' shape=() dtype=float32>, <tf.Tensor 'l2_regularizer_2:0' shape=() dtype=float32>, <tf.Tensor 'l2_regularizer_3:0' shape=() dtype=float32>, <tf.Tensor 'Sum:0' shape=() dtype=float32>]\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\tf_should_use.py:118: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "epoch  0  loss      :  641290170.078125\n",
      "epoch  0  accuracy  :  0.9265091\n",
      "epoch  0  accuracy_t:  0.9192\n",
      "epoch  1  loss      :  215743544.578125\n",
      "epoch  1  accuracy  :  0.9530727\n",
      "epoch  1  accuracy_t:  0.9338\n",
      "epoch  2  loss      :  149314421.359375\n",
      "epoch  2  accuracy  :  0.9712727\n",
      "epoch  2  accuracy_t:  0.9421\n",
      "epoch  3  loss      :  115624280.84375\n",
      "epoch  3  accuracy  :  0.9788182\n",
      "epoch  3  accuracy_t:  0.9484\n",
      "epoch  4  loss      :  99926824.734375\n",
      "epoch  4  accuracy  :  0.9796909\n",
      "epoch  4  accuracy_t:  0.9487\n",
      "epoch  5  loss      :  90684718.203125\n",
      "epoch  5  accuracy  :  0.9911636\n",
      "epoch  5  accuracy_t:  0.9565\n",
      "epoch  6  loss      :  85055251.8125\n",
      "epoch  6  accuracy  :  0.99021816\n",
      "epoch  6  accuracy_t:  0.9551\n",
      "epoch  7  loss      :  81989642.6875\n",
      "epoch  7  accuracy  :  0.98989093\n",
      "epoch  7  accuracy_t:  0.955\n",
      "epoch  8  loss      :  79775022.34375\n",
      "epoch  8  accuracy  :  0.99283636\n",
      "epoch  8  accuracy_t:  0.9573\n",
      "epoch  9  loss      :  77354431.875\n",
      "epoch  9  accuracy  :  0.98623633\n",
      "epoch  9  accuracy_t:  0.9524\n",
      "epoch  10  loss      :  75590055.453125\n",
      "epoch  10  accuracy  :  0.99554545\n",
      "epoch  10  accuracy_t:  0.9604\n",
      "epoch  11  loss      :  75422366.53125\n",
      "epoch  11  accuracy  :  0.9956727\n",
      "epoch  11  accuracy_t:  0.9607\n",
      "epoch  12  loss      :  73049648.359375\n",
      "epoch  12  accuracy  :  0.9955091\n",
      "epoch  12  accuracy_t:  0.9606\n",
      "epoch  13  loss      :  72344895.8671875\n",
      "epoch  13  accuracy  :  0.99561816\n",
      "epoch  13  accuracy_t:  0.9612\n",
      "epoch  14  loss      :  71617674.828125\n",
      "epoch  14  accuracy  :  0.99585456\n",
      "epoch  14  accuracy_t:  0.9636\n",
      "epoch  15  loss      :  69940265.3359375\n",
      "epoch  15  accuracy  :  0.99612725\n",
      "epoch  15  accuracy_t:  0.9612\n",
      "epoch  16  loss      :  69513056.25\n",
      "epoch  16  accuracy  :  0.9969818\n",
      "epoch  16  accuracy_t:  0.9635\n",
      "epoch  17  loss      :  68685057.1953125\n",
      "epoch  17  accuracy  :  0.99758184\n",
      "epoch  17  accuracy_t:  0.9624\n",
      "epoch  18  loss      :  67536443.765625\n",
      "epoch  18  accuracy  :  0.9977273\n",
      "epoch  18  accuracy_t:  0.9648\n",
      "epoch  19  loss      :  66598270.8515625\n",
      "epoch  19  accuracy  :  0.9951636\n",
      "epoch  19  accuracy_t:  0.9619\n",
      "训练准确率:  0.9951636\n",
      "测试准确率:  0.9619\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_neural_network(X=x, Y=y, epochs=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 多隐层\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 隐层神经元数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
